…|play|pause}` (aiidateam#6902)

The original design of `wait` and `timeout` was to distinguish between actions
that immediately return and actions that scheduled. This mechanism was however
never used and resulted in an misinterpretation in the force-kill PR aiidateam#6793
introducing a bug fixed in PR $6870. The mechanism of `wait` and `timeout` was
also never correctly implemented. In this PR we rectify the logic and simplify
it by handling immediate and scheduled actions the same way.

My interpretation is that the original logic (seen in commit 8388018) is that it
unwraps the future once, if it is a another future then it is a scheduled action
otherwise an immediate one. Then 1b6ecb8 in plumpy introduced a double wrapping
for `play`, `pause` and `kill` of the return value which I think is correct as
these are scheduled actions. The problem appears in cd0d15c where on the
aiida-core side in the first round unwrapping is always done till the actual
(nonfuture) result by using `unwrap_kiwi_future`. This makes the usage of
`wait` completely obsolete as we always get the final nonfuture result in the
first step. Also the `timeout` was not passed to the `result` which made it a
blocking action for scheduled tasked (the `timeout` is only applied on the
first layer of future in `futures.as_completed` which is meaningless since the
first layer is always a future and returns immediately).

This is fixed by simplifying the two step procedure, unwrap once and if future
unwrap again, to one step: Unwrap until nonfuture result gained with timeout.
One can specify a `timeout == 0` to express that the action should not wait for
a response while one can specify `timeout==float('inf')` (default value) to wait
until a response has been received without a timeout.